class RegalosController < ApplicationController
  before_filter :login_required, :except => [:nuevo, :create_prueba, :show, :invitacion, :update_prueba, :regalo_preview, :update_refact, :create_refact]
  before_filter :comprueba_acceso, :only => :show
  
  def index
  end
  
  # Listado de regalos enviados
  def enviados
    @regalos = find_regalos("remitidos", params[:tipo])
    @rol = "remitente"
    render :action => :index
  end
  
  # Listado de regalos recibidos
  def recibidos
    @regalos = find_regalos("recibidos", params[:tipo])    
    @rol = "invitado"
    render :action => :index
  end
  
  # Acción que permitirá ver el regalo en caso de tener el hash code correcto.
  def invitacion
    hash = params[:invitacion][:codigo]
    
    if (Regalo.es_valido?("remitente", hash) || Regalo.es_valido?("invitado", hash))
      redirect_to prueba_regalo_path(:id => hash.split("-")[0], :hash => hash)
    else
      flash[:error] = "Información de la invitación incorrecta"
      redirect_back_or_default('/')
    end
  end
  
  # Acción que muestra un regalo en particular.
  def show
    if logged_in?  
      Evento.update_all("visto = true", ["usuario_id = ? and regalo_id = ? and visto = ?", current_usuario.id, @regalo.id, false])
    end

    respond_to do |format|
      format.html # show.rhtml        
    end
  end
  
  # Método ajax que actualiza la previsualización del regalo conforme
  # vayamos rellenando el formulario.
  def regalo_preview    
    render :partial =>"shared/regalo_preview", 
           :locals => { :tipo_regalo => params[:regalo][:tipo_regalo_id], 
                        :texto => params[:regalo][:texto],
                        :nick => params[:regalo][:nick_mostrado] }
  end

  # Vista con nuestro formulario de nuevo regalo.
  def nuevo
    @regalo = Regalo.new
  end

  # Metodo común a create y create_prueba
  def create_refact
    @regalo = Regalo.new(params[:regalo])

    plantilla = Plantilla.find(1) # FIXME: que se pueda elegir la plantilla de verdad
    tipo_regalo = TipoRegalo.find(params[:regalo][:tipo_regalo_id])

    @regalo.plantilla = plantilla
    @regalo.tipo_regalo = tipo_regalo

    @regalo.fecha_terminado = (Time.now + (params[:regalo][:fecha_terminado].to_i).days).midnight + 1.day
  end
  
  # Método que crea un regalo.
  def create
    create_refact
    
    #Comprobamos si existe el usuario al q queremos enviar
    if params[:invitado][:login] != ""
      invitado = Usuario.find_by_login(params[:invitado][:login])      
      if invitado == nil
        flash[:error]  = "El usuario al que quieres invitar no existe"
      else
        @regalo.invitado_id = invitado.id
      end
    end

    @regalo.remitente = current_usuario

    respond_to do |format|
      if @regalo.save
        flash[:notice] = "Tu regalo ha sido creado y enviado al destinatario"
        RegaloMailer.deliver_aviso_regalo_nuevo(@regalo, "invitado")
        format.html { redirect_to usuario_regalo_path(current_usuario.login, @regalo)  }
      else
        format.html { render :action => "nuevo" }
      end
    end
  end
 
  # Método que crea un regalo de prueba.
  def create_prueba
    create_refact
    
    @regalo.email_remitente = params[:regalo][:email_remitente]

    respond_to do |format|
      if @regalo.save
        flash[:notice] = "Tu regalo ha sido enviado al destinatario.<br/>
                          Te hemos enviado un correo con los datos de acceso a tu mensaje."
        flash[:alert] = "¡ No olvides revisar tu Correo No Deseado !"
        RegaloMailer.deliver_aviso_regalo_nuevo(@regalo, "invitado")
        RegaloMailer.deliver_aviso_regalo_nuevo(@regalo, "remitente")
        format.html { redirect_to main_path }
      else
        format.html { render :action => "nuevo" }
      end
    end
  end
  
  # Metodo común a update y update_prueba  
  def update_refact
    @regalo = Regalo.find(params[:id])

    if params[:accion] == "Aceptar"
      @regalo.state = "aceptado"
    elsif params[:accion] == "Rechazar"
      @regalo.state = "rechazado"
    end
  end
  
  # Método que actualiza un regalo.
  def update
    update_refact

    respond_to do |format|
      if @regalo.save
        flash[:notice] = "El regalo ha sido actualizado."
        format.html { 
          RegaloMailer.deliver_aviso_regalo_cambio_estado(@regalo, "remitente")
          redirect_to usuario_regalo_path(current_usuario.login, @regalo)
        }
      else
        flash[:error] = "El regalo no ha sido actualizado."
        format.html { redirect_to usuario_regalo_path(current_usuario.login, @regalo) }
      end
    end
  end

  # Método que actualiza un regalo de prueba.
  def update_prueba
    update_refact
    
    respond_to do |format|
      if Regalo.es_valido?("invitado", params[:hash]) && @regalo.save

        flash[:notice] = "El regalo ha sido actualizado."
        format.html { 
          RegaloMailer.deliver_aviso_regalo_cambio_estado(@regalo, "remitente")
          redirect_to prueba_regalo_path(:id => @regalo.id) + "?hash=#{params[:hash]}"
        }
      end
    end
  end
  
  
  def auto_complete_belongs_to_for_regalo_invitado_login
    query = params[:invitado][:login].downcase
    query = "%#{query}%"
    @usuarios = current_usuario.amigos_aceptados.find(:all, :conditions => ['LOWER(login) LIKE ?', query], :limit => 10)
    render :partial => 'regalo_invitado_completions'
  end

  def auto_complete_for_invitado_login
    encontrados = Usuario.find(:all, 
    :conditions => [ 'LOWER(login) LIKE ?', '%' + params[:invitado][:login].downcase + '%' ],
    :order => "login desc", :limit => 10) 
    @amigos = encontrados - Usuario.find(:all, :conditions =>["login = ? or login = ?", current_usuario.login, "admin"])
    render :partial => "auto_complete_amigo"
  end
  
  #Acción "local" para comprobar como vemos los emails
  def aviso
    @regalo = Regalo.find(params[:id])  
    render(:layout => false)      
  end
  
  
  protected  
  
  # Método que devuelve cierto si el +tipo+ es correcto, falso en caso contrario. 
  def tipo_valido(tipo)
    regalos_validos = ["aceptados", "rechazados", "pendientes"]

    return true if regalos_validos.include? tipo
    false    
  end
  
  # Método que nos devuelve, según el +envio+ ("recibidos" o "enviados") 
  # y +tipo+ ("aceptados", "rechazados", "pendientes" o "todos"), el listado 
  # de regalos correspondiente paginado.
  def find_regalos(envio, tipo)
    relaciones = {"aceptados" => "current_usuario.regalos_#{envio}_aceptados",
    "rechazados" => "current_usuario.regalos_#{envio}_rechazados",
    "pendientes" => "current_usuario.regalos_#{envio}_pendientes",
    "todos" => "current_usuario.regalos_#{envio}"}

    if tipo_valido(tipo)
      @regalos = eval(relaciones[tipo])
    else
      @regalos = eval(relaciones["todos"])
    end
    @num_regalos = @regalos.size # lo requerimos para hacer los intervalos
    @regalos = @regalos.paginate(:page => params[:page], :per_page => 5, :order => "created_at desc")  
  end
end